// Markdown 预览工具
class MarkdownPreview {
    // 简单的 Markdown 解析器，支持常用语法
    static parseMarkdown(markdown) {
        try {
            if (!markdown || typeof markdown !== 'string') {
                return { success: false, error: 'Markdown内容不能为空' };
            }

            let html = markdown;

            // 预处理：转义HTML特殊字符（除了已经是HTML标签的部分）
            html = html.replace(/&/g, '&amp;')
                      .replace(/</g, '&lt;')
                      .replace(/>/g, '&gt;')
                      .replace(/"/g, '&quot;')
                      .replace(/'/g, '&#x27;');

            // 恢复一些常见的HTML实体用于后续处理
            html = html.replace(/&amp;/g, '&')
                      .replace(/&lt;/g, '<')
                      .replace(/&gt;/g, '>');

            // 代码块（三个反引号包围）- 必须在内联代码之前处理
            html = html.replace(/```(\w+)?\n([\s\S]*?)\n```/g, (match, lang, code) => {
                const language = lang || 'text';
                const escapedCode = code.replace(/&/g, '&amp;')
                                       .replace(/</g, '&lt;')
                                       .replace(/>/g, '&gt;');
                return `<pre><code class="language-${language}">${escapedCode}</code></pre>`;
            });

            // 内联代码（单个反引号包围）
            html = html.replace(/`([^`]+)`/g, '<code>$1</code>');

            // 标题（从h6到h1，避免匹配冲突）
            html = html.replace(/^###### (.*$)/gm, '<h6>$1</h6>');
            html = html.replace(/^##### (.*$)/gm, '<h5>$1</h5>');
            html = html.replace(/^#### (.*$)/gm, '<h4>$1</h4>');
            html = html.replace(/^### (.*$)/gm, '<h3>$1</h3>');
            html = html.replace(/^## (.*$)/gm, '<h2>$1</h2>');
            html = html.replace(/^# (.*$)/gm, '<h1>$1</h1>');

            // 粗体和斜体
            html = html.replace(/\*\*\*(.*?)\*\*\*/g, '<strong><em>$1</em></strong>');
            html = html.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
            html = html.replace(/\*(.*?)\*/g, '<em>$1</em>');

            // 删除线
            html = html.replace(/~~(.*?)~~/g, '<del>$1</del>');

            // 链接
            html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noopener noreferrer">$1</a>');

            // 图片
            html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" style="max-width: 100%; height: auto;">');

            // 无序列表
            html = html.replace(/^\s*[\*\-\+]\s+(.*)$/gm, '<li>$1</li>');
            html = html.replace(/(<li>.*<\/li>)/s, '<ul>$1</ul>');
            html = html.replace(/<\/ul>\s*<ul>/g, ''); // 合并连续的列表

            // 有序列表
            html = html.replace(/^\s*\d+\.\s+(.*)$/gm, '<li>$1</li>');
            // 注意：这里需要更复杂的逻辑来区分有序和无序列表，简化处理

            // 引用
            html = html.replace(/^>\s*(.*)$/gm, '<blockquote>$1</blockquote>');
            html = html.replace(/<\/blockquote>\s*<blockquote>/g, '<br>'); // 合并连续引用

            // 水平线
            html = html.replace(/^---$/gm, '<hr>');
            html = html.replace(/^\*\*\*$/gm, '<hr>');

            // 表格（简单实现）
            const tableRegex = /^\|(.+)\|\s*\n\|[-\s|:]+\|\s*\n((?:\|.+\|\s*\n?)+)/gm;
            html = html.replace(tableRegex, (match, header, rows) => {
                const headerCells = header.split('|').map(cell => `<th>${cell.trim()}</th>`).join('');
                const headerRow = `<tr>${headerCells}</tr>`;
                
                const bodyRows = rows.trim().split('\n').map(row => {
                    const cells = row.split('|').filter(cell => cell.trim()).map(cell => `<td>${cell.trim()}</td>`).join('');
                    return `<tr>${cells}</tr>`;
                }).join('');
                
                return `<table class="markdown-table"><thead>${headerRow}</thead><tbody>${bodyRows}</tbody></table>`;
            });

            // 段落处理（将连续的文本行合并为段落）
            const paragraphs = html.split('\n\n');
            html = paragraphs.map(paragraph => {
                const trimmed = paragraph.trim();
                if (!trimmed) return '';
                
                // 检查是否已经是HTML元素
                if (trimmed.match(/^<(h[1-6]|ul|ol|li|blockquote|pre|code|table|hr)/)) {
                    return trimmed;
                }
                
                return `<p>${trimmed.replace(/\n/g, '<br>')}</p>`;
            }).filter(p => p).join('\n');

            return {
                success: true,
                data: {
                    html: html,
                    original: markdown,
                    wordCount: this.getWordCount(markdown),
                    readingTime: this.getReadingTime(markdown)
                }
            };
        } catch (error) {
            return { success: false, error: `Markdown解析失败: ${error.message}` };
        }
    }

    // 获取字数统计
    static getWordCount(text) {
        if (!text) return 0;
        
        // 移除Markdown语法字符
        const cleanText = text
            .replace(/[#*`>\-\+\[\]()!]/g, '') // 移除Markdown标记
            .replace(/\s+/g, ' ') // 合并空白字符
            .trim();
        
        // 统计中文字符和英文单词
        const chineseChars = (cleanText.match(/[\u4e00-\u9fa5]/g) || []).length;
        const englishWords = (cleanText.match(/[a-zA-Z]+/g) || []).length;
        
        return chineseChars + englishWords;
    }

    // 获取阅读时间（分钟）
    static getReadingTime(text) {
        const wordCount = this.getWordCount(text);
        // 中文阅读速度约为300-500字/分钟，英文约为200-300词/分钟
        const readingSpeed = 400; // 平均阅读速度
        const minutes = Math.ceil(wordCount / readingSpeed);
        return Math.max(1, minutes); // 最少1分钟
    }

    // 导出为HTML文件
    static exportToHTML(markdown, title = 'Markdown Document') {
        try {
            const parseResult = this.parseMarkdown(markdown);
            if (!parseResult.success) {
                return parseResult;
            }

            const htmlTemplate = `<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>${title}</title>
    <style>
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Helvetica Neue', Arial, sans-serif;
            line-height: 1.6;
            color: #333;
            max-width: 800px;
            margin: 0 auto;
            padding: 20px;
            background: #fff;
        }
        h1, h2, h3, h4, h5, h6 {
            margin-top: 24px;
            margin-bottom: 16px;
            font-weight: 600;
            line-height: 1.25;
        }
        h1 { font-size: 2em; border-bottom: 1px solid #eaecef; padding-bottom: 10px; }
        h2 { font-size: 1.5em; border-bottom: 1px solid #eaecef; padding-bottom: 8px; }
        h3 { font-size: 1.25em; }
        p { margin-bottom: 16px; }
        code {
            background: #f6f8fa;
            border-radius: 3px;
            padding: 2px 6px;
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
            font-size: 85%;
        }
        pre {
            background: #f6f8fa;
            border-radius: 6px;
            padding: 16px;
            overflow: auto;
            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
            line-height: 1.45;
        }
        pre code {
            background: transparent;
            padding: 0;
            border-radius: 0;
        }
        blockquote {
            border-left: 4px solid #dfe2e5;
            padding-left: 16px;
            margin: 16px 0;
            color: #6a737d;
        }
        ul, ol { padding-left: 20px; margin-bottom: 16px; }
        li { margin-bottom: 4px; }
        table {
            border-collapse: collapse;
            width: 100%;
            margin: 16px 0;
        }
        th, td {
            border: 1px solid #dfe2e5;
            padding: 8px 12px;
            text-align: left;
        }
        th {
            background: #f6f8fa;
            font-weight: 600;
        }
        a {
            color: #0366d6;
            text-decoration: none;
        }
        a:hover {
            text-decoration: underline;
        }
        hr {
            border: 0;
            height: 1px;
            background: #eaecef;
            margin: 24px 0;
        }
        img {
            max-width: 100%;
            height: auto;
            border-radius: 6px;
            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
        }
    </style>
</head>
<body>
    ${parseResult.data.html}
</body>
</html>`;

            return {
                success: true,
                data: {
                    html: htmlTemplate,
                    filename: `${title.replace(/[^a-zA-Z0-9\u4e00-\u9fa5]/g, '_')}.html`
                }
            };
        } catch (error) {
            return { success: false, error: `导出HTML失败: ${error.message}` };
        }
    }

    // 获取Markdown目录结构
    static generateTOC(markdown) {
        try {
            if (!markdown) {
                return { success: true, data: [] };
            }

            const headings = [];
            const lines = markdown.split('\n');
            
            lines.forEach((line, index) => {
                const match = line.match(/^(#{1,6})\s+(.+)$/);
                if (match) {
                    const level = match[1].length;
                    const text = match[2].trim();
                    const id = text.toLowerCase()
                                  .replace(/[^a-zA-Z0-9\u4e00-\u9fa5\s]/g, '')
                                  .replace(/\s+/g, '-');
                    
                    headings.push({
                        level,
                        text,
                        id,
                        line: index + 1
                    });
                }
            });

            return { success: true, data: headings };
        } catch (error) {
            return { success: false, error: `生成目录失败: ${error.message}` };
        }
    }

    // 验证Markdown语法
    static validateMarkdown(markdown) {
        try {
            if (!markdown) {
                return { success: true, data: { isValid: true, warnings: [] } };
            }

            const warnings = [];
            const lines = markdown.split('\n');

            lines.forEach((line, index) => {
                const lineNum = index + 1;
                
                // 检查链接语法
                const linkMatches = line.match(/\[([^\]]*)\]\(([^)]*)\)/g);
                if (linkMatches) {
                    linkMatches.forEach(match => {
                        const urlMatch = match.match(/\[([^\]]*)\]\(([^)]*)\)/);
                        if (urlMatch && !urlMatch[2]) {
                            warnings.push({
                                line: lineNum,
                                message: '链接URL为空',
                                type: 'link'
                            });
                        }
                    });
                }

                // 检查图片语法
                const imgMatches = line.match(/!\[([^\]]*)\]\(([^)]*)\)/g);
                if (imgMatches) {
                    imgMatches.forEach(match => {
                        const urlMatch = match.match(/!\[([^\]]*)\]\(([^)]*)\)/);
                        if (urlMatch && !urlMatch[2]) {
                            warnings.push({
                                line: lineNum,
                                message: '图片URL为空',
                                type: 'image'
                            });
                        }
                    });
                }

                // 检查代码块配对
                const codeBlockMarkers = (line.match(/```/g) || []).length;
                if (codeBlockMarkers % 2 !== 0) {
                    warnings.push({
                        line: lineNum,
                        message: '代码块标记可能未配对',
                        type: 'codeblock'
                    });
                }
            });

            return {
                success: true,
                data: {
                    isValid: warnings.length === 0,
                    warnings: warnings,
                    summary: `检查完成，发现 ${warnings.length} 个警告`
                }
            };
        } catch (error) {
            return { success: false, error: `Markdown验证失败: ${error.message}` };
        }
    }

    // 获取预设模板
    static getTemplates() {
        return {
            success: true,
            data: {
                'readme': {
                    name: 'README模板',
                    content: `# 项目标题

项目的简短描述

## 特性

- 特性1
- 特性2
- 特性3

## 安装

\`\`\`bash
npm install project-name
\`\`\`

## 使用方法

\`\`\`javascript
const project = require('project-name');
project.doSomething();
\`\`\`

## 贡献

欢迎提交 Issue 和 Pull Request！

## 许可证

MIT License`
                },
                'api-doc': {
                    name: 'API文档模板',
                    content: `# API 文档

## 概述

API的基本信息和说明

## 认证

API使用说明

## 端点

### GET /api/users

获取用户列表

**参数：**

| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| page   | int  | 否   | 页码 |
| limit  | int  | 否   | 每页数量 |

**响应：**

\`\`\`json
{
  "code": 200,
  "data": [
    {
      "id": 1,
      "name": "用户名",
      "email": "user@example.com"
    }
  ]
}
\`\`\`

## 错误码

| 错误码 | 说明 |
|--------|------|
| 400    | 请求参数错误 |
| 401    | 未授权 |
| 500    | 服务器内部错误 |`
                },
                'blog': {
                    name: '博客文章模板',
                    content: `# 文章标题

> 文章摘要或引言

## 目录

- [介绍](#介绍)
- [主要内容](#主要内容)
- [结论](#结论)

## 介绍

文章的介绍内容...

## 主要内容

### 小节1

内容描述...

### 小节2

内容描述...

\`\`\`javascript
// 代码示例
function example() {
    console.log('Hello, World!');
}
\`\`\`

## 结论

文章总结...

---

*作者：[你的名字](链接)*  
*发布时间：${new Date().toLocaleDateString()}*`
                }
            }
        };
    }
}